/**
 * 根据叶子节点的 value 向上反查出整条路径
 * @param leafValue  后台保存的最后一位 value
 * @param options    Cascader 的完整 options 树
 * @returns          路径数组；若找不到则返回空数组
 */
export function findCascaderPath(leafValue: number | string, options: any[]): (number | string)[] {
  // 深度优先搜索
  const dfs = (nodes: any[], target: number | string, path: (number | string)[]): (number | string)[] | null => {
    if (!Array.isArray(nodes)) return null

    for (const node of nodes) {
      const curPath = [...path, node.value]

      // 命中叶子
      if (node.value === target) return curPath

      // 继续往 children 里找
      if (Array.isArray(node.children)) {
        const found = dfs(node.children, target, curPath)
        if (found) return found
      }
    }
    return null
  }

  const result = dfs(options, leafValue, [])
  return result || []
}

/**
 * 将后台树形数据转成 Cascader options
 * @param list 后台原始数组
 * @returns Cascader 可用的 options
 */
export function toCascaderOptions(list: any[]) {
  const convert = (nodes: any[]): any[] =>
    nodes.map((node) => ({
      value: node.id,
      label: node.name,
      children: node.child?.length ? convert(node.child) : undefined,
    }))
  return convert(list)
}

const hexList: string[] = []
for (let i = 0; i <= 15; i++) {
  hexList[i] = i.toString(16)
}
/**
 * 生成全球唯一标识
 * @returns uuid
 */
export function uuid(): string {
  let uuid = ''
  for (let i = 1; i <= 36; i++) {
    switch (i) {
      case 9:
      case 14:
      case 19:
      case 24: {
        uuid += '-'

        break
      }
      case 15: {
        uuid += 4

        break
      }
      case 20: {
        uuid += hexList[(Math.random() * 4) | 8]

        break
      }
      default: {
        uuid += hexList[Math.trunc(Math.random() * 16)]
      }
    }
  }
  return uuid
}

/*
 * 根据运行环境获取基础请求URL
 */
export const getUrl = (): string => {
  return import.meta.env.VITE_GLOB_API_URL as string
}

// 获取当前时间字符串
export function getNowTimeStr(): string {
  const now = new Date()
  const year = String(now.getFullYear()).padStart(4, '0')
  const month = String(now.getMonth() + 1).padStart(2, '0') // 注意月份是从0开始的
  const day = String(now.getDate()).padStart(2, '0')
  const hour = String(now.getHours()).padStart(2, '0')
  const minute = String(now.getMinutes()).padStart(2, '0')
  const second = String(now.getSeconds()).padStart(2, '0')
  return `${year}${month}${day}${hour}${minute}${second}`
}
/**
 * 递归函数，用于生成完整的路径
 * 优化后的版本能够正确处理多层嵌套的树形结构，生成完整的路径链
 */
export const generatePaths = (parentId, options) => {
  const result = [];

  // 递归查找函数，深度遍历整个树形结构
  const findChildrenRecursively = (nodes, currentId, currentPath = []) => {
    if (!Array.isArray(nodes)) return;

    for (const node of nodes) {
      // 如果找到匹配的父节点ID
      if (node.id === currentId) {
        const newPath = [...currentPath, node.id];

        // 如果有子节点，递归遍历所有子节点
        if (node.children && node.children.length > 0) {
          // 先将当前路径添加到结果中
          result.push(newPath);

          // 再递归处理所有子节点
          node.children.forEach(child => {
            findChildrenRecursively([child], child.id, newPath);
          });
        } else {
          // 如果没有子节点，直接添加当前路径
          result.push(newPath);
        }
      }
      // 如果当前节点不是目标节点，但有子节点，继续递归查找
      else if (node.children && node.children.length > 0) {
        findChildrenRecursively(node.children, currentId, currentPath);
      }
    }
  };

  // 启动递归查找
  findChildrenRecursively(options, parentId);

  return result;
};

/**
 * 查找三级分类的完整路径
 * 专门用于处理categoryOptions.value数据结构
 * @param selectedData 用户选择的数据
 * @param options 完整的分类树形结构
 * @returns 三级分类的完整路径数组，格式如[[264, 274, 324], [264, 274, 543]]
 */
export const completeCategoryPaths = (selectedData, options) => {
  const result = [];

  // 如果输入不是数组，直接返回空数组
  if (!Array.isArray(selectedData)) return result;

  selectedData.forEach(path => {
    // 确保path是数组
    if (!Array.isArray(path) || path.length === 0) return;

    const lastId = path[path.length - 1];

    // 定义递归查找函数来查找完整的节点
    const findNodeById = (nodes, id) => {
      for (const node of nodes) {
        if (node.value === id) {
          return node;
        }
        if (node.children && node.children.length > 0) {
          const found = findNodeById(node.children, id);
          if (found) return found;
        }
      }
      return null;
    };

    // 查找完整的节点信息
    const lastNode = findNodeById(options, lastId);

    if (lastNode) {
      // 检查是否为第三级分类（没有children或children为空）
      if (!lastNode.children || lastNode.children.length === 0) {
        // 如果已经是叶子节点（第三级），直接添加完整路径
        result.push(path);
      } else if (lastNode.children && lastNode.children.length > 0) {
        // 如果不是叶子节点，递归遍历所有子节点，直到找到第三级分类
        const traverseToThirdLevel = (node, currentPath) => {
          // 创建当前节点的完整路径
          const newPath = [...currentPath, node.value];

          // 检查是否为第三级分类
          if (node.children && node.children.length > 0) {
            // 继续向下遍历
            node.children.forEach(child => {
              traverseToThirdLevel(child, newPath);
            });
          } else {
            // 已到达第三级，添加完整路径
            result.push([...path.slice(0, -1), ...newPath]);
          }
        };

        // 开始遍历子节点，查找第三级分类
        lastNode.children.forEach(child => {
          traverseToThirdLevel(child, [lastId]);
        });
      }
    }
  });

  return result;
};

/**
 * 将用户选择的数据补全到所有层级
 * 优化后的版本能够正确处理多层嵌套的树形结构，生成如 [8, 24, 345] 这样的三维数组数据
 */
export const completePaths = (selectedData, options) => {
  const result = [];
  // 如果输入不是数组，直接返回空数组
  if (!Array.isArray(selectedData)) return result;

  selectedData.forEach(path => {
    // 确保path是数组
    if (!Array.isArray(path) || path.length === 0) return;

    const lastId = path[path.length - 1];

    // 定义递归查找函数来查找完整的树形结构
    const findNodeRecursively = (nodes, id) => {
      for (const node of nodes) {
        if (node.id === id) {
          return node;
        }
        if (node.children && node.children.length > 0) {
          const found = findNodeRecursively(node.children, id);
          if (found) return found;
        }
      }
      return null;
    };

    // 查找完整的节点信息，包括所有层级
    const lastOption = findNodeRecursively(options, lastId);

    if (lastOption && lastOption.children && lastOption.children.length > 0) {
      // 递归遍历所有子节点路径
      const traverseChildren = (node, parentPath) => {
        // 创建当前节点的完整路径
        const currentPath = [...parentPath, node.id];

        // 如果有子节点，继续递归遍历
        if (node.children && node.children.length > 0) {
          node.children.forEach(child => {
            traverseChildren(child, currentPath);
          });
        } else {
          // 如果没有子节点，将完整路径添加到结果中
          result.push([...path.slice(0, -1), ...currentPath]);
        }
      };

      // 开始遍历子节点
      lastOption.children.forEach(child => {
        traverseChildren(child, [lastId]);
      });
    } else {
      // 如果当前选择的路径没有子选项，直接添加
      result.push(path);
    }
  });

  return result;
};
